home *** CD-ROM | disk | FTP | other *** search
/ BMUG PD-ROM 1995 Fall / PD-ROM F95.toast / Telecom / Terminal Programs / Terminal 2.0.1 ƒ / Srcs / Serial.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-12-19  |  14.2 KB  |  582 lines  |  [TEXT/ttxt]
  1. /*
  2.     Terminal 2.0
  3.     "Serial.c"
  4. */
  5.  
  6. #ifdef THINK_C
  7. #include "MacHeaders"
  8. #define CREFNUM(x)    x.ioRefNum
  9. #endif
  10. #ifdef applec
  11. #pragma load ":(Objects):MacHeadersMPW"
  12. #pragma segment Main2
  13. #define CREFNUM(x)    x.ioCRefNum
  14. #endif
  15.  
  16. #include "Serial.h"
  17. #include "Text.h"
  18. #include "Main.h"
  19.  
  20. #ifdef USECTB                    /* Communication Tool Box includes */
  21. #ifdef THINK_C
  22. #include <CRMIntf.h>
  23. #include <CRMSerialIntf.h>
  24. #endif
  25. #ifdef applec
  26. #include <CommResources.h>
  27. #include <CRMSerialDevices.h>
  28. #endif
  29. #endif
  30.  
  31. #define INPUTLENGTH Config.input        /* Size of input buffer */
  32. #define CURRENTPORT    Settings.portName    /* Current port's name */
  33.  
  34. typedef    struct {
  35.         Byte *name;                /* Port's name */
  36.         Byte *input;            /* Input driver's name */
  37.         Byte *output;            /* Output driver's name */
  38. } SERIALNAME;
  39.  
  40. /* ----- Static data --------------------------------------------------- */
  41.  
  42. static short INPUT = 0;            /* Current input reference number */
  43. static short OUTPUT = 0;        /* Current output reference number */
  44. static short PORTNO = 0;        /* 1 = Modem Port, 2 = Printer Port */
  45. static Ptr inputBuffer = 0;        /* Current input buffer */
  46. static Ptr outputBuffer = 0;    /* Current output buffer */
  47.  
  48. #define baud38400    1            /* Not definded in SerialDvr.h */
  49.  
  50. static short Baud[] = {            /* Baud rates we support */
  51.     baud300,                    /* 0 */
  52.     baud600,                    /* 1 */
  53.     baud1200,                    /* 2 */
  54.     baud2400,                    /* 3 */
  55.     baud4800,                    /* 4 */
  56.     baud9600,                    /* 5 */
  57.     baud19200,                    /* 6 */
  58.     baud38400,                    /* 7 */
  59.     baud57600                    /* 8 */
  60. };
  61. static short Data[] = {            /* Data bits we support */
  62.     data7,                        /* 0 */
  63.     data8                        /* 1 */
  64. };
  65. static short Parity[] = {        /* Parity options we support */
  66.     noParity,                    /* 0 */
  67.     evenParity,                    /* 1 */
  68.     oddParity                    /* 2 */
  69. };
  70. static short StopBits[] = {        /* Stop bits we support */
  71.     stop10,                        /* 0 */
  72.     stop20                        /* 1 */
  73. };
  74.  
  75. static SERIALNAME Names[] = {    /* Used without Communication Tool Box */
  76.         { (Byte *)"\pModem Port", (Byte *)"\p.AIn", (Byte *)"\p.AOut" },
  77.         { (Byte *)"\pPrinter Port", (Byte *)"\p.BIn", (Byte *)"\p.BOut" }
  78. };
  79.  
  80. /* ----- Find serial devices ------------------------------------------- */
  81.  
  82. void SerialDevice(ProcPtr callback)
  83. {
  84.     /*    Loop thru all serial devices and call the "callback" function
  85.         with the following arguments:
  86.             1. Index (one based)
  87.             2. Port's name
  88.             3. Input driver's name
  89.             4. Output driver's name
  90.         The "callback" function should return TRUE to stop the search,
  91.         or FALSE to continue. */
  92.  
  93. #ifdef USECTB
  94.     if (CTB) {            /* Communications Toolbox is available */
  95.         register CRMRec *p;
  96.         register long old;
  97.         register CRMSerialRecord *ser;
  98.         register short index;
  99.         CRMRec r;
  100.  
  101.         memset(&r, 0, sizeof(r));
  102.         r.qType = crmType;
  103.         for (old = 0, index = 1; ; old = p->crmDeviceID, ++index) {
  104.             r.crmDeviceType = crmSerialDevice;
  105.             r.crmDeviceID = old;
  106.             if (!(p = (CRMRec *)CRMSearch((QElemPtr)(p = &r))))
  107.                 break;
  108.             ser = (CRMSerialRecord *)p->crmAttributes;
  109.             if ((* callback)(index, *(ser->name), *(ser->inputDriverName),
  110.                     *(ser->outputDriverName)))
  111.                 break;    /* Stop search */
  112.         }
  113.     } else
  114. #endif
  115.     {                /* Communications Toolbox not available */
  116.         register short index;
  117.         register SERIALNAME *p;
  118.  
  119.         for (index = 0, p = Names;
  120.                 index < sizeof(Names)/sizeof(SERIALNAME);
  121.                 ++index, ++p)
  122.             if ((* callback)(index + 1, p->name, p->input, p->output))
  123.                 break;    /* Stop search */
  124.     }
  125. }
  126.  
  127. /* ----- Open serial driver -------------------------------------------- */
  128.  
  129. static short OpenErr;        /* Driver open error */
  130. static Byte *OpenName;        /* Port's name to find */
  131.  
  132. static short OpenSerial(    /* "callback" function for "SerialDevice" */
  133.     short index,
  134.     Byte *name,
  135.     Byte *input,
  136.     Byte *output)
  137. {
  138.     if (!EqualString(name, OpenName, FALSE, TRUE))
  139.         return FALSE;        /* Not the name we want, continue */
  140.     if (OpenErr = OpenDriver(input, &INPUT))
  141.         return TRUE;        /* Name ok, but error during open, stop */
  142.     if (OpenErr = OpenDriver(output, &OUTPUT)) {
  143.         CloseDriver(INPUT);    /* Output open error */
  144.         INPUT = OUTPUT = 0;
  145.     } else {
  146.         DTR = TRUE;            /* Input & output open ok, DTR asserted */
  147.         PORTNO = index;
  148.     }
  149.     return TRUE;            /* Stop, port was found */
  150. }
  151.  
  152. static short OpenSerialDriver(
  153.     Byte *port)                /* Port's name (e.g. "\pModem Port") */
  154. {
  155.     OpenName = port;
  156.     OpenErr = 1;            /* If no port with this name is found */
  157.     DTR = FALSE;            /* DTR negated until port is open */
  158.     PORTNO = 0;
  159.     SerialDevice((ProcPtr)OpenSerial);
  160.     return OpenErr;
  161. }
  162.  
  163. /* ----- Calculate serial duration ------------------------------------- */
  164.  
  165. /*    Note: using speed changing modems (while using MNP4 or MNP5) this
  166.     leads to wrong results... */
  167.  
  168. long SerialDuration(
  169.     register short setup,    /* Serial chip setup word */
  170.     register short bytes)    /* Number of bytes in buffer */
  171. {
  172.     register short bits;    /* Bits per bytes */
  173.     register long bps;        /* Bits per second (*100) */
  174.     short baud, data, parity, stop;
  175.     static long b[] = {        /* Baud * 100 */
  176.         30000, 60000, 120000, 240000, 480000,
  177.         960000, 1920000, 3840000, 5760000 };
  178.  
  179.     SerialGetSetup(setup, &baud, &data, &parity, &stop);
  180.     bits =
  181.         1 +                    /* Start bit */
  182.         7 + data +            /* Data bits (7 or 8) */
  183.         (parity ? 1 : 0) +    /* Parity bit (0 or 1) */
  184.         1 + stop;            /* Stop bits (1 or 2) */
  185.     bps = b[baud];
  186.     return ((long)bits * (long)bytes * 6015L) / bps;
  187. }
  188.  
  189. /* ----- Set serial parameters ----------------------------------------- */
  190.  
  191. void SerialReset(
  192.     register short setup)    /* Serial chip setup word */
  193. {
  194.     SerReset(OUTPUT, setup);
  195.     SerReset(INPUT, setup);
  196. }
  197.  
  198. /* ----- Set to 8 data bits and no parity (binary file transfers) ------ */
  199.  
  200. void SerialBinary(
  201.     register short setup)    /* Serial chip setup word */
  202. {
  203.     /* Parity   : bits 13 - 12 (0, 1, 2, 3 for no, odd, no, even) */
  204.     /* Data bits: bits 11 - 10 (0, 1, 2, 3 for 5, 7, 6, 8) */
  205.     /* --00 11-- ---- ---- */
  206.  
  207.     SerialReset((setup & 0xC3FF) | 0x0C00);
  208. }
  209.  
  210. /* ----- See if set to 8 data bits ------------------------------------- */
  211.  
  212. Boolean Serial8Bits(
  213.     register short setup)    /* Serial chip setup word */
  214. {
  215.     /* Parity   : bits 13 - 12 (0, 1, 2, 3 for no, odd, no, even) */
  216.     /* Data bits: bits 11 - 10 (0, 1, 2, 3 for 5, 7, 6, 8) */
  217.     /* --00 11-- ---- ---- */
  218.  
  219.     return (setup & 0x0C00) == 0x0C00;
  220. }
  221.  
  222. /* ----- DTR on exit, drop or no drop ---------------------------------- */
  223.  
  224. void SerialDropDTR(register Boolean nodrop)
  225. {
  226.     CntrlParam c;
  227.  
  228.     if (!OUTPUT)
  229.         return;
  230.     CREFNUM(c) = OUTPUT;
  231.     c.csParam[0] = nodrop ? 0x8000 : 0x0000;
  232.     c.csCode = 16;
  233.     PBControl((ParmBlkPtr)&c, FALSE);
  234. }
  235.  
  236. /* ----- Set serial handshake ------------------------------------------ */
  237.  
  238. void SerialHandshake(
  239.     register short how)        /* 0=none,1=XON/XOFF,2=CTS,3=DTR,4=CTS/DTR */
  240. {
  241.     CntrlParam c;
  242.     register SerShk *handshake;
  243.  
  244.     if (!OUTPUT)
  245.         return;
  246.     CREFNUM(c) = OUTPUT;
  247.     c.csCode = 14;                /* SerHShake */
  248.     handshake = (SerShk *)&c.csParam[0];
  249.     handshake->fXOn = 0;        /* no XON/XOFF output flow control */
  250.     handshake->fCTS = 0;        /* no CTS (input) hardware handshake */
  251.     handshake->xOn  = 0x00;        /* XON character */
  252.     handshake->xOff = 0x00;        /* XOFF character */
  253.     handshake->errs = 0;        /* Ignore input errors */
  254.     handshake->evts = 0;        /* No device driver events */
  255.     handshake->fInX = 0;        /* no XON/XOFF input flow control */
  256.     handshake->fDTR = 0;        /* no DTR (output) hardware handshake */
  257.     switch(how) {
  258.         case 1:        /* XON/XOFF */
  259.             handshake->fXOn = 1;    /* XON/XOFF output flow control */
  260.             handshake->xOn  = 0x11;    /* XON character (ctrl-Q) */
  261.             handshake->xOff = 0x13;    /* XOFF character (ctrl-S) */
  262.             break;
  263.         case 2:        /* CTS */
  264.             handshake->fCTS = 1;    /* CTS (input) hardware handshake */
  265.             break;
  266.         case 3:        /* DTR */
  267.             handshake->fDTR = 1;    /* DTR (output) hardware handshake */
  268.             break;
  269.         case 4:        /* CTS/DTR */
  270.             handshake->fCTS = handshake->fDTR = 1;
  271.             break;
  272.     }
  273.     PBControl((ParmBlkPtr)&c, FALSE);
  274. }
  275.  
  276. /* ----- Get serial port setup ----------------------------------------- */
  277.  
  278. short SerialGetSetup(
  279.     register short setup,    /* Serial chip setup word */
  280.     short *baud,            /* 0=300 Baud ... */
  281.     short *data,            /* 0=7 bits ... */
  282.     short *parity,            /* 0=none ... */
  283.     short *stop)            /* 0=1 stop bits ... */
  284. {
  285.     register short i;
  286.     register short v;
  287.  
  288.     *baud = *data = *parity = *stop = 0;
  289.  
  290.     v = setup & 0x03FF;                    /* Baud rate: bits 9 - 0 */
  291.     for (i = 0; i < sizeof(Baud)/sizeof(short); i++)
  292.         if (v == Baud[i]) {
  293.             *baud = i;
  294.             break;
  295.         }
  296.     if (i >= sizeof(Baud)/sizeof(short))
  297.         return 1;
  298.  
  299.     v = setup & 0x0C00;                    /* Data bits: bits 11 - 10 */
  300.     for (i = 0; i < sizeof(Data)/sizeof(short); i++)
  301.         if (v == Data[i]) {
  302.             *data = i;
  303.             break;
  304.         }
  305.     if (i >= sizeof(Data)/sizeof(short))
  306.         return 2;
  307.  
  308.     v = setup & 0x3000;                    /* Parity: bits 13 - 12 */
  309.     for (i = 0; i < sizeof(Parity)/sizeof(short); i++)
  310.         if (v == Parity[i]) {
  311.             *parity = i;
  312.             break;
  313.         }
  314.     if (i >= sizeof(Parity)/sizeof(short))
  315.         return 3;
  316.  
  317.     v = setup & 0xC000;                    /* Stop bits: bits 15 - 14 */
  318.     for (i = 0; i < sizeof(StopBits)/sizeof(short); i++)
  319.         if (v == StopBits[i]) {
  320.             *stop = i;
  321.             break;
  322.         }
  323.     if (i >= sizeof(StopBits)/sizeof(short))
  324.         return 4;
  325.  
  326.     return 0;
  327. }
  328.  
  329. /* ----- Set serial port setup ----------------------------------------- */
  330.  
  331. short SerialSetSetup(
  332.     register short baud,    /* 0=300 Baud ... */
  333.     register short data,    /* 0=7 bits ... */
  334.     register short parity,    /* 0=none ... */
  335.     register short stop,    /* 0=1 stop bits ... */
  336.     register short *setup)    /* Serial chip setup word */
  337. {
  338.     *setup = Baud[0] | Data[0] | Parity[0] | StopBits[0];
  339.     if (baud < 0 || baud >= sizeof(Baud)/sizeof(short))
  340.         return 1;
  341.     if (data < 0 || data >= sizeof(Data)/sizeof(short))
  342.         return 2;
  343.     if (parity < 0 || parity >= sizeof(Parity)/sizeof(short))
  344.         return 3;
  345.     if (stop < 0 || stop >= sizeof(StopBits)/sizeof(short))
  346.         return 4;
  347.     *setup = Baud[baud] | Data[data] | Parity[parity] | StopBits[stop];
  348.     return 0;
  349. }
  350.  
  351. /* ----- Close serial port --------------------------------------------- */
  352.  
  353. void SerialClose(void)
  354. {
  355.     /*    Warning! VERY BAD THINGS CAN HAPPEN (Perhaps even loss of data
  356.         on your hard disk!) long after your program quits if you forget
  357.         to do this, or forget to close the driver properly!
  358.         It is essential that you do not ever leave a custom input buffer
  359.         dangling, EVEN if you abort your program for some other reason!
  360.         The OS will NOT fix this up for you! You have been warned! */
  361.  
  362.     if (INPUT) {
  363.         SerSetBuf(INPUT, inputBuffer, 0);
  364.         CloseDriver(INPUT);
  365.         INPUT = 0;
  366.     }
  367.     if (OUTPUT) {
  368.         SerSetBuf(OUTPUT, outputBuffer, 0);
  369.         CloseDriver(OUTPUT);
  370.         OUTPUT = 0;
  371.     }
  372. }
  373.  
  374. /* ----- Open serial port and set parameters --------------------------- */
  375.  
  376. short SerialOpen(
  377.     register Byte *port,        /* Port's name (e.g. "\pModem Port") */
  378.     register short setup,        /* Serial chip setup word */
  379.     register short handshake)    /* 0=none ... */
  380. {
  381.     register short err;
  382.  
  383.     memcpy(CURRENTPORT, port, *port + 1);
  384.     if (port[0] == 0)            /* It's ok to use the "none" port */
  385.         return 0;
  386.     if (err = OpenSerialDriver(port))
  387.         return err;
  388.     /* Keep input buffer if already allocated */
  389.     if (!inputBuffer && !(inputBuffer = NewPtr(INPUTLENGTH))) {
  390.         SerialClose();
  391.         return memFullErr;
  392.     }
  393.     SerSetBuf(INPUT, inputBuffer, INPUTLENGTH);
  394.     SerialHandshake(handshake);
  395.     SerialReset(setup);
  396.     return 0;                    /* Ok */
  397. }
  398.  
  399. /* ----- Read characters from serial port ------------------------------ */
  400.  
  401. void SerialFastRead(
  402.     register Byte *buffer,
  403.     register long count)
  404. {
  405.     IOParam b;
  406.  
  407.     if (!INPUT)
  408.         return;
  409.     b.ioRefNum = INPUT;
  410.     b.ioBuffer = (Ptr)buffer;
  411.     b.ioReqCount = count;
  412.     PBRead((ParmBlkPtr)&b, FALSE);
  413. }
  414.  
  415. /* ----- Read characters from serial port ------------------------------ */
  416.  
  417. long SerialRead(
  418.     register Byte *buffer,
  419.     register long max)
  420. {
  421.     register long n;
  422.     CntrlParam c;
  423.     IOParam b;
  424.  
  425.     if (!INPUT)
  426.         return 0;
  427.     CREFNUM(c) = INPUT;
  428.     c.csCode = 2;
  429.     if (PBStatus((ParmBlkPtr)&c, FALSE))
  430.         return 0;
  431.     if (n = *(long *)&c.csParam[0]) {
  432.         b.ioRefNum = INPUT;
  433.         b.ioBuffer = (Ptr)buffer;
  434.         b.ioReqCount = (max > n) ? n : max;
  435.         return PBRead((ParmBlkPtr)&b, FALSE) ? 0 : b.ioReqCount;
  436.     }
  437.     return 0;    /* Nothing available */
  438. }
  439.  
  440. /* ----- Flush serial input buffer ------------------------------------- */
  441.  
  442. void SerialFlush(void)
  443. {
  444.     CntrlParam b;
  445.  
  446.     if (!INPUT)
  447.         return;
  448.     CREFNUM(b) = INPUT;
  449.     b.ioCompletion = 0;
  450.     PBKillIO((ParmBlkPtr)&b, FALSE);
  451. }
  452.  
  453. /* ----- Abort serial send --------------------------------------------- */
  454.  
  455. void SerialAbort(void)
  456. {
  457.     CntrlParam b;
  458.  
  459.     if (!OUTPUT)
  460.         return;
  461.     CREFNUM(b) = OUTPUT;
  462.     b.ioCompletion = 0;
  463.     PBKillIO((ParmBlkPtr)&b, FALSE);
  464. }
  465.  
  466. /* ----- Send buffer --------------------------------------------------- */
  467.  
  468. static pascal void SendComplete(void);
  469.  
  470. #ifdef THINK_C
  471. static pascal void SendComplete()
  472. {
  473.     /* A0 has address of IOParam */
  474.     asm {
  475.         MOVE.L    -4(A0),A0    /* Get busy flag address */
  476.         CLR.B    0(A0)        /* Clear the busy flag (FALSE) */
  477.     }
  478. }
  479. #endif
  480.  
  481. void SerialSend(
  482.     register Byte *buffer,
  483.     register long count,
  484.     register Boolean *busy)
  485. {
  486.     static struct {        /* Must be static! */
  487.         Boolean *busy;    /* TRUE while sending */
  488.         IOParam b;
  489.     } param;
  490.  
  491.     if (!OUTPUT) {
  492.         *busy = FALSE;
  493.         return;
  494.     }
  495.     *busy = TRUE;
  496.     param.busy = busy;
  497.     param.b.ioCompletion = (ProcPtr)SendComplete;
  498.     param.b.ioRefNum = OUTPUT;
  499.     param.b.ioBuffer = (Ptr)buffer;
  500.     param.b.ioReqCount = count;
  501.     PBWrite((ParmBlkPtr)¶m.b, TRUE);        /* Asynchrone */
  502. }
  503.  
  504. /* ----- See how many bytes are in input buffer ------------------------ */
  505.  
  506. long SerialCheck(void)
  507. {
  508.     CntrlParam c;
  509.  
  510.     if (!INPUT)
  511.         return 0;
  512.     CREFNUM(c) = INPUT;
  513.     c.csCode = 2;
  514.     if (!PBStatus((ParmBlkPtr)&c, FALSE))
  515.         return *(long *)&c.csParam[0];
  516.     return 0;
  517. }
  518.  
  519. /* ----- Negate or assert DTR ------------------------------------------ */
  520.  
  521. void SerialDTR(
  522.     register Boolean how)    /* FALSE: negate, TRUE:assert */
  523. {
  524.     CntrlParam c;
  525.  
  526.     if (!OUTPUT)
  527.         return;
  528.     CREFNUM(c) = OUTPUT;
  529.     c.csCode = how ? 17 : 18;
  530.     PBControl((ParmBlkPtr)&c, FALSE);
  531.     DTR = how;
  532. }
  533.  
  534. /* ----- Check CTS/DCD ------------------------------------------------- */
  535.  
  536. /*
  537.     Pin number    Signal name        Signal description
  538.  
  539.         1            HSKo        Output Handshake (SCC DTR output)
  540.         2            HSKi        Input Handshake (SCC CTS input)
  541.         7            GPi            General-purpose input (SCC DCD input)
  542. */
  543.  
  544. #ifdef QUICK_AND_DIRTY
  545.  
  546. Boolean SerialCTS(void)
  547. {
  548.     register Byte r;
  549.  
  550.     if (!INPUT || PORTNO < 1 || PORTNO > 2)
  551.         return FALSE;
  552.     r = *(SCCRd + ((PORTNO == 2) ? 0 : 2));    /* SCC channel A/B control */
  553.     return !(r & 0x20);                        /* CTS is bit 5 */
  554. }
  555.  
  556. #else
  557.  
  558. Boolean SerialCTS(void)
  559. {
  560.     CntrlParam c;
  561.  
  562.     if (!INPUT)
  563.         return 0;
  564.     CREFNUM(c) = INPUT;
  565.     c.csCode = 8;
  566.     if (!PBStatus((ParmBlkPtr)&c, FALSE))
  567.         return !((SerStaRec *)&c.csParam[0])->ctsHold;
  568.     return 0;
  569. }
  570.  
  571. #endif
  572.  
  573. Boolean SerialDCD(void)
  574. {
  575.     register Byte r;
  576.  
  577.     if (!INPUT || PORTNO < 1 || PORTNO > 2)
  578.         return FALSE;
  579.     r = *(SCCRd + ((PORTNO == 2) ? 0 : 2));    /* SCC channel A/B control */
  580.     return !(r & 0x08);                        /* DCD is bit 3 */
  581. }
  582.